De klasse meetkundige Vormen maken

.Net is een object georiënteerde omgeving waarbij functies zijn ondergebracht in klassen. Een klasse is een geheel van methoden en eigenschappen. Je kan programma’s schrijven in C# zonder ook maar een keer aan object georiënteerd te denken. Het is m.i. echter aangeraden vanaf het begin op een object georiënteerde manier te denken en te programmeren. Zelfs al heb je in het begin nog geen al te goed begrip van wat dat eigenlijk nu juist is.

Doelstelling

Na deze les weet je wat:

namespaces
klassen
velden
eigenschappen
methoden
overloads

zijn en kan je deze structuur toepassen in eenvoudige projecten.

Leerpad

Orde in .NET
We gaan het object georiënteerd programmeren stap voor stap bijbrengen. We beginnen hier met één aspect van object georiënteerd programmeren: orde!

orde in dotnet
Een nieuw klassenbestand toevoegen aan je project in Visual Studio:
1. Klik met de rechtermuisknop op de BeginnenMetCSharp map. In het Add New Item dialoogvenster kies je om een klasse toe te voegen:
  
  Nieuw klassenbestand toevoegen
2. Geef het de naam Vormen.cs:
  
  Nieuw klassen bestand met de naam Vormen
3. Het bestand Vormen.cs wordt geopend in de code editor met daarin de volgende code:
```
using System;
using System.Collections.Generic;
using System.Text;

namespace BeginnenMetCSharp
{
    class Vormen
    {
    }
}
```
Een naam voor de namespace kiezen. De naam van een namespace wordt in pascalnotatie geschreven.
Er zijn verschillende manieren om de namespaces te organiseren. De keuze moet worden gebaseerd op de afspraken binnen je team en de aard van het project waaraan je werkt. Namespaces passen in de volgende hiërarchie: We veranderen de opgegeven namespace en typen de namespace Wiskunde.Meetkunde in:
```
namespace Wiskunde.Meetkunde
{
    ...
}
```
- Namespace
  - Type
    - Type Leden
Klasse toevoegen, de naam van een klasse wordt in pascalnotatie geschreven.
Maak een klasse met de naam Vormen:
```
namespace Wiskunde.Meetkunde
{
    class Vormen
    {
     ...
    }
}
```
Properties of eigenschappen toevoegen:
1. We beginnen met een field of veld met de naam kleur aan de klasse toe te voegen. De naam van een veld wordt in camelcasenotatie geschreven. Het gegevenstype van kleur is ConsoleColor. Dat is een gegevenstype die gedeclareerd staat in de namespace System. We declaren het veld kleur als volgt
```
namespace Wiskunde.Meetkunde
{
    class Vormen
    {
        private ConsoleColor kleur;
        .
        .
        .
    }
}
```
2. We voegen vervolgens de eigenschap Kleur toe. De naam van een eigenschap wordt in pascalnotatie geschreven. Daarmee gegeven we aan in welke kleur de vorm getekend moet worden. Een property of een eigenschap heeft een getter en en setter. Met een setter methode kunnen we de waarde van het veld kleur instellen. Met een getter kunnen de waarde van het private veld kleur opvragen. De property is net zoals he veld kleur van het gegevenstype ConsoleColor:
```
namespace Wiskunde.Meetkunde
{
    class Vormen
    {
        private ConsoleColor kleur;
        public ConsoleColor Kleur
        {
            get { return kleur; }
            set
            {
                kleur= value;
                Console.ForegroundColor = kleur;
            }
        }
        .
        .
        .
    }
}
```
Tensolotte voegen we een methode toe aan de klasse.
Maak de Lijn() methode die een lijn maakt van een opgegeven aantal koppeltekens '-' en die lijn retourneert naar het calling programma.
1. Vermits deze methode een string retourneert moeten we in de declaratie van de methode het gegevenstype string opgeven.
2. De methode is static omdat we wanneer we deze methode willen gebruiken niet eerst een instantie van de klasse Vormen moeten aanmaken.
3. De methode is public omdat we de methode van buiten de klasse moeten kunnen oproepen.
4. De methode heeft een parameter waarmee we opgeven uit hoeveel tekens de lijn bestaat. Het gegevenstype van de parameter is int:
```
namespace Wiskunde.Meetkunde
{
    class Vormen
    {
        public static string Lijn(int lengte)
        {
            return new string('-', lengte);
        }
    }
}
```
De klasse gebruiken in Program.cs
We hebben de klasse nu gemaakt en kunnen die in de Main methode van de Program klasse gebruiken. Als argument van de Lijn methode geven we 20 mee. Dat wil zeggen dat de Lijn methode een lijn van 20 koppeltekens zal retourneren. We moeten niet eerst een instantie maken van de Vormen klasse om de Lijn methode aan te roepen. Immers deze methode hebben we in de klasse gedeclareerd als static. We roepen de methode op door gewoon de naam van de klasse in te typen gevolgd door de naam van de methode. We typen ook de namespace voor de methode in zodat Visual Studio weet waar de klasse staat. We hadden ook aan het begin van het programma het statement using Wiskunde.Meetkunde; kunnen intypen:
```
using System;

namespace BeginnenMetCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            string familienaam = "Jan Janssens";
            Console.WriteLine("Hello World!");
            Console.WriteLine(familienaam);
            Console.WriteLine(Wiskunde.Meetkunde.Vormen.Lijn(20));
            Console.ReadKey();
        }
    }
}
```
Een overload methode toevoegen om een lijn met een ander teken te tekenen
Een overload methode in een klasse is een methode met dezelfde naam als een reeds bestaande methode maar met andere parameters.
Ofwel heeft de parameter een ander gegevenstype ofwel zijn er meer of minder parameters. Als voorbeeld maken we een overload van de Lijn methode door een parameter met de naam teken toe voegen waarmee we kunnen opgeven met welk teken de lijn getekend moet worden:
```
public static string Lijn(int lengte, char teken)
{
    return new string(teken, lengte);
}
```

Opdracht

Maak methode voor de volgende vormen:
1. rechthoek
2. driehoek
Wijzig de klasse zodat het mogelijk is om ook het teken te kiezen waarmee de vorm getekend wordt.
Je kan de kleur en het teken wijzigen met een set property. Voeg ook overload methoden toe waarmee je de vormen kan tekenen én de kleur of het teken opgeven. In het totaal heb je daarvoor voor elke vorm vier overloads nodig:
1. een om de vorm te tekenen
2. een om de vorm te tekenen in een bepaalde kleur
3. een om de vorm te tekenen met een bepaald teken
4. een om de vorm te tekenen in een bepaald kleur met een bepaald teken
Synchroniseer je workspace op Cloud9 met behulp van GIT:
1. Bewaar je werk in een lokale git repo.
2. Plaats in de commentaar van de commit de volgende message: "Oefening OO Meetkundige vormen - final" (deze boodschap moet identiek zijn in je commit).
3. Push je lokale repo naar Bitbucket.
4. En synchroniseer tenslotte je workspace op Cloud9.
Deadline: 18 april 2018

2018-03-25 17:38:09